#include "../src/juego.h"

#define forn(i,n)       for(Nat i = 0; i < (n); ++i)

using namespace std;

void test_crear(ostream&){

	// ++ Se crear el Tablero a utilizar en el Juego (6 casillas en total)
	Tablero<String> t;

	String m0("mcero"), m1("muno"), m2("mdos"), m2_2("mdosbis"), m3("mtres"),
			m4("mcuatro"), m5("mcinco");

	//Se agrega una nueva casilla en un el mismo continente que 0, conectada de ida y vuelta con la casilla
	t.Contener(0, m0, m1);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(1, m1, m2);
	//Se agrega una nueva conexión de 1 a 2
	t.Movilizar(1, 2, m2_2);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m3);
	//Se agrega una conexión de ida y vuelta entre 0 y 3
	t.Conectar(0, 3, m3, m0);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m4);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(4, m4, m5);

	// ++ Se crean los vectores de casillas iniciales y misiones para 3 jugadores
	Vector<Casilla> cs;
	Vector<Mision> ms;
	//Jugador 0
	cs.AgregarAtras(2);
	ms.AgregarAtras(1);
	//Jugador 1
	cs.AgregarAtras(1);
	ms.AgregarAtras(2);
	//Jugador 2
	cs.AgregarAtras(5);
	ms.AgregarAtras(0);

	// ++ Se crea la instancia de Juego
	Juego juego(t, cs, ms);

	// ++ Tests

	//Chequeo de la información del tablero
	Conj<Casilla> casillasJuego = juego.Casillas();
	Conj<Continente> continentesJuego = juego.Continentes();
	AFIRMAR(juego.TableroDelJuego() == t);
	AFIRMAR(juego.TableroDelJuego().Casillas() == casillasJuego);
	AFIRMAR(juego.TableroDelJuego().Continentes() == continentesJuego);

	//Debe haber 3 jugadores
	ConjAcotado::const_Iterador itJugs = juego.Jugadores();

	NEGAR(itJugs.HayAnterior());
	AFIRMAR(itJugs.HaySiguiente());
	itJugs.Avanzar();
	AFIRMAR(itJugs.HaySiguiente());
	itJugs.Avanzar();
	AFIRMAR(itJugs.HaySiguiente());
	itJugs.Avanzar();
	NEGAR(itJugs.HaySiguiente());

	//Se chequean las misiones
	ASEGURAR(juego.MisionDe(0), 1);
	ASEGURAR(juego.MisionDe(1), 2);
	ASEGURAR(juego.MisionDe(2), 0);

	//Se chequean las misiones
	ASEGURAR(juego.FichasAgregadas(0), 0);
	ASEGURAR(juego.FichasAgregadas(1), 0);
	ASEGURAR(juego.FichasAgregadas(2), 0);

	//Se chequean las casillas
	AFIRMAR(juego.Vacia(0));
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1) ,  1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2) ,  0);
	AFIRMAR(juego.Vacia(3));
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5) ,  2);

	NEGAR(juego.Disputada(0));
	NEGAR(juego.Disputada(1));
	NEGAR(juego.Disputada(2));
	NEGAR(juego.Disputada(3));
	NEGAR(juego.Disputada(4));
	NEGAR(juego.Disputada(5));

	//Chequeo de fichas por jugador
	AFIRMAR(juego.TieneFichas(0));
	AFIRMAR(juego.TieneFichas(1));
	AFIRMAR(juego.TieneFichas(2));

	ASEGURAR(juego.CantidadConFichas(), 3);

	MultConjAcotado::const_Iterador itMult = juego.Fichas(0);
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(1);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  1 );
	ASEGURAR(itMult.CardinalSiguiente() ,  1 );
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(2);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  0 );
	ASEGURAR(itMult.CardinalSiguiente() ,  1 );
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(3);
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(4);
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(5);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  2 );
	ASEGURAR(itMult.CardinalSiguiente() ,  1 );
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	//Chequeo de dominancia por jugador
	ASEGURAR(juego.PorDominar(0) ,  2);
	ASEGURAR(juego.PorDominar(1) ,  1);
	ASEGURAR(juego.PorDominar(2) ,  2);

	ConjAcotado::const_Iterador itDoms = juego.Dominadas(0);
	NEGAR(itDoms.HayAnterior());
	AFIRMAR(itDoms.HaySiguiente());
	ASEGURAR(itDoms.Siguiente() ,  2);
	itDoms.Avanzar();
	NEGAR(itDoms.HaySiguiente());

	itDoms = juego.Dominadas(1);
	NEGAR(itDoms.HayAnterior());
	AFIRMAR(itDoms.HaySiguiente());
	ASEGURAR(itDoms.Siguiente() ,  1);
	itDoms.Avanzar();
	NEGAR(itDoms.HaySiguiente());

	itDoms = juego.Dominadas(2);
	NEGAR(itDoms.HayAnterior());
	AFIRMAR(itDoms.HaySiguiente());
	ASEGURAR(itDoms.Siguiente() ,  5);
	itDoms.Avanzar();
	NEGAR(itDoms.HaySiguiente());

	//Chequeo de condiciones de fin de juego
	NEGAR(juego.MisionCumplida(0));
	NEGAR(juego.MisionCumplida(1));
	NEGAR(juego.MisionCumplida(2));
	NEGAR(juego.Finalizado());
	ASEGURAR(juego.Eliminados().Cardinal(), 0);
	ASEGURAR(juego.CumplieronMision().Cardinal(), 0);

	//Chequeo de PuedeAgregar(jug, cas)
	// -- Jugador 0
	AFIRMAR(juego.PuedeAgregar(0, 0));
	NEGAR(juego.PuedeAgregar(0, 1));
	AFIRMAR(juego.PuedeAgregar(0, 2));
	AFIRMAR(juego.PuedeAgregar(0, 3));
	AFIRMAR(juego.PuedeAgregar(0, 4));
	NEGAR(juego.PuedeAgregar(0, 5));

	// -- Jugador 1
	AFIRMAR(juego.PuedeAgregar(1, 0));
	AFIRMAR(juego.PuedeAgregar(1, 1));
	NEGAR(juego.PuedeAgregar(1, 2));
	AFIRMAR(juego.PuedeAgregar(1, 3));
	AFIRMAR(juego.PuedeAgregar(1, 4));
	NEGAR(juego.PuedeAgregar(1, 5));

	// -- Jugador 2
	AFIRMAR(juego.PuedeAgregar(2, 0));
	NEGAR(juego.PuedeAgregar(2, 1));
	NEGAR(juego.PuedeAgregar(2, 2));
	AFIRMAR(juego.PuedeAgregar(2, 3));
	AFIRMAR(juego.PuedeAgregar(2, 4));
	AFIRMAR(juego.PuedeAgregar(2, 5));
}

void test_agregarFicha(ostream&){
	// ++ Se crear el Tablero a utilizar en el Juego (6 casillas en total)
	Tablero<String> t;

	String m0("mcero"), m1("muno"), m2("mdos"), m2_2("mdosbis"), m3("mtres"),
			m4("mcuatro"), m5("mcinco");

	//Se agrega una nueva casilla en un el mismo continente que 0, conectada de ida y vuelta con la casilla
	t.Contener(0, m0, m1);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(1, m1, m2);
	//Se agrega una nueva conexión de 1 a 2
	t.Movilizar(1, 2, m2_2);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m3);
	//Se agrega una conexión de ida y vuelta entre 0 y 3
	t.Conectar(0, 3, m3, m0);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m4);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(4, m4, m5);

	// ++ Se crean los vectores de casillas iniciales y misiones para 3 jugadores
	Vector<Casilla> cs;
	Vector<Mision> ms;
	//Jugador 0
	cs.AgregarAtras(2);
	ms.AgregarAtras(1);
	//Jugador 1
	cs.AgregarAtras(1);
	ms.AgregarAtras(2);
	//Jugador 2
	cs.AgregarAtras(5);
	ms.AgregarAtras(0);

	// ++ Se crea la instancia de Juego
	Juego juego(t, cs, ms);

	//Jugador 0 agrega una ficha a casilla vacia
	juego.AgregarFicha(0, 3);

	//Se chequea cantidad de fichas
	ASEGURAR(juego.FichasAgregadas(0),1);
	ASEGURAR(juego.FichasAgregadas(1),0);
	ASEGURAR(juego.FichasAgregadas(2),0);

	//Se chequean las casillas
	AFIRMAR(juego.Vacia(0));
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1) ,  1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2) ,  0);
	AFIRMAR(juego.Dominada(3));
	ASEGURAR(juego.Dominador(3), 0);
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5) ,  2);

	NEGAR(juego.Disputada(0));
	NEGAR(juego.Disputada(1));
	NEGAR(juego.Disputada(2));
	NEGAR(juego.Disputada(3));
	NEGAR(juego.Disputada(4));
	NEGAR(juego.Disputada(5));

	//Chequeo de fichas por jugador
	AFIRMAR(juego.TieneFichas(0));
	AFIRMAR(juego.TieneFichas(1));
	AFIRMAR(juego.TieneFichas(2));

	ASEGURAR(juego.CantidadConFichas(), 3);

	MultConjAcotado::const_Iterador itMult = juego.Fichas(0);
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(1);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  1 );
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(2);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  0 );
	ASEGURAR(itMult.CardinalSiguiente() ,  1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(3);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 0);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(4);
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(5);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  2);
	ASEGURAR(itMult.CardinalSiguiente() ,  1 );
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	//Chequeo de dominancia por jugador
	ASEGURAR(juego.PorDominar(0) ,  1);
	ASEGURAR(juego.PorDominar(1) ,  1);
	ASEGURAR(juego.PorDominar(2) ,  2);

	ConjAcotado::const_Iterador itDoms = juego.Dominadas(0);
	NEGAR(itDoms.HayAnterior());
	AFIRMAR(itDoms.HaySiguiente());
	AFIRMAR(itDoms.Siguiente() == 2 || itDoms.Siguiente() == 3 );
	itDoms.Avanzar();
	AFIRMAR(itDoms.HaySiguiente());
	AFIRMAR((itDoms.Siguiente() == 3 && itDoms.Anterior() == 2) || (itDoms.Siguiente() == 2 && itDoms.Anterior() == 3) );
	itDoms.Avanzar();
	NEGAR(itDoms.HaySiguiente());

	itDoms = juego.Dominadas(1);
	NEGAR(itDoms.HayAnterior());
	AFIRMAR(itDoms.HaySiguiente());
	ASEGURAR(itDoms.Siguiente() ,  1);
	itDoms.Avanzar();
	NEGAR(itDoms.HaySiguiente());

	itDoms = juego.Dominadas(2);
	NEGAR(itDoms.HayAnterior());
	AFIRMAR(itDoms.HaySiguiente());
	ASEGURAR(itDoms.Siguiente() ,  5);
	itDoms.Avanzar();
	NEGAR(itDoms.HaySiguiente());

	//Jugador 0 agrega una ficha a casilla dominada
	juego.AgregarFicha(0,2);

	//Jugador 1 agrega una ficha a casilla vacia
	juego.AgregarFicha(1,0);
	//Jugador 1 agrega una ficha a casilla dominada
	juego.AgregarFicha(1,1);

	//Jugador 2 agrega una ficha a casilla dominada
	juego.AgregarFicha(2,5);


	//Se chequean la cantidad de fichas
	ASEGURAR(juego.FichasAgregadas(0), 2);
	ASEGURAR(juego.FichasAgregadas(1), 2);
	ASEGURAR(juego.FichasAgregadas(2), 1);

	//Se chequean las casillas
	AFIRMAR(juego.Dominada(0));
	ASEGURAR(juego.Dominador(0), 1);
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1) ,  1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2) ,  0);
	AFIRMAR(juego.Dominada(3));
	ASEGURAR(juego.Dominador(3), 0);
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5) ,  2);

	itMult=juego.Fichas(0);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 1);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
	
	itMult = juego.Fichas(1);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  1 );
	ASEGURAR(itMult.CardinalSiguiente(), 2);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(2);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  0);
	ASEGURAR(itMult.CardinalSiguiente() ,  2 );
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(3);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 0);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(4);
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(5);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  2);
	ASEGURAR(itMult.CardinalSiguiente() ,  2 );
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());	
}

void test_mover(ostream&){
	// ++ Se crear el Tablero a utilizar en el Juego (6 casillas en total)
	Tablero<String> t;
	
	String m0("mcero"), m1("muno"), m2("mdos"), m2_2("mdosbis"), m3("mtres"),
			m4("mcuatro"), m5("mcinco"), m6("mseis");

	//Se agrega una nueva casilla en un el mismo continente que 0, conectada de ida y vuelta con la casilla
	t.Contener(0, m0, m1);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(1, m1, m2);
	//Se agrega una nueva conexión de 1 a 2
	t.Movilizar(1, 2, m2_2);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m3);
	//Se agrega una conexión de ida y vuelta entre 0 y 3
	t.Conectar(0, 3, m3, m0);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m4);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(4, m4, m5);

	// ++ Se crean los vectores de casillas iniciales y misiones para 3 jugadores
	Vector<Casilla> cs;
	Vector<Mision> ms;
	//Jugador 0
	cs.AgregarAtras(2);
	ms.AgregarAtras(1);
	//Jugador 1
	cs.AgregarAtras(1);
	ms.AgregarAtras(2);
	//Jugador 2
	cs.AgregarAtras(5);
	ms.AgregarAtras(0);

	// ++ Se crea la instancia de Juego
	Juego juego(t, cs, ms);

	//No hay casillas disputadas

	//Movimiento no existente
	//Mover(jugador, mov, cant fichas)
	juego.Mover(0, m6,1);

	//No hay cambios en las casillas
	AFIRMAR(juego.Vacia(0));
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1), 1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2), 0);
	AFIRMAR(juego.Vacia(3));
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5), 2);

	//Movimiento existente pero jugador no tiene fichas en ninguna casilla con ese mov de salida
	juego.Mover(2, m3, 1);
	
	//No hay cambios en las casillas 
	AFIRMAR(juego.Vacia(0));  
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1), 1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2), 0);
	AFIRMAR(juego.Vacia(3));
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5), 2);
	
	//Jugador 0 agrega 2 fichas en la casilla 2 
	juego.AgregarFicha(0, 2);
	juego.AgregarFicha(0, 2);

	//Mover menor cantidad de fichas
	juego.Mover(0, m3, 1);
	//Jugador0 mueve de las 3 fichas, 1. 

	//Chequeo de casillas
	AFIRMAR(juego.Vacia(0));
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1), 1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2), 0);
	AFIRMAR(juego.Dominada(3));
	ASEGURAR(juego.Dominador(3), 0);
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5), 2);
	
	MultConjAcotado::const_Iterador itMult = juego.Fichas(2);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  0);
	ASEGURAR(itMult.CardinalSiguiente(), 2);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(3);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  0);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	//Mover igual cantidad de fichas
	juego.Mover(0, m0, 1);

	//Chequeo de casillas
	AFIRMAR(juego.Dominada(0));
	ASEGURAR(juego.Dominador(0), 0);
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1), 1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2), 0);
	AFIRMAR(juego.Vacia(3));
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5), 2);
	
	itMult = juego.Fichas(0);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 0);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
	
	itMult = juego.Fichas(1);
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 1);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());

	itMult = juego.Fichas(3); //casilla queda vacía porque se movió única ficha 
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());

	//Mover mayor cantidad de fichas que las existentes en la casilla 
	juego.Mover(1,m0,3); //Jugador1 mueve su unica ficha        

	//Chequeo de casillas  
	AFIRMAR(juego.Disputada(0));    
	AFIRMAR(juego.Vacia(1));
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2), 0);
	AFIRMAR(juego.Vacia(3));
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));		
	ASEGURAR(juego.Dominador(5), 2);
	
	
	itMult = juego.Fichas(0);
	
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	AFIRMAR(itMult.Siguiente() == 0 || itMult.Siguiente() == 1);
	ASEGURAR(itMult.CardinalSiguiente() ,  1);
	itMult.Avanzar();
	AFIRMAR(itMult.HaySiguiente());
	AFIRMAR((itMult.Siguiente() == 1 && itMult.Anterior() == 0) || (itMult.Siguiente() == 0 && itMult.Anterior() == 1));
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
		
	itMult = juego.Fichas(1);      //casilla queda vacia porque se movio unica ficha 
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());


	//Caso hay casillas disputadas
		
	//Jugador1 agrega 2 fichas a casilla 1 
	juego.AgregarFicha(1,1); 
	juego.AgregarFicha(1,1); 
	//Jugador2 agrega 2 fichas a casilla 3
	juego.AgregarFicha(2,3); 
	juego.AgregarFicha(2,3); 
		
	//Casilla 1 disputada por jugador0 y 1, c/u con 1 ficha
		
	//Jugador2 mueve 1 ficha a la casilla 1  
	juego.Mover(2, m0,1); 
		
	//Batalla en casilla 1, perdedor jugador1
		
	//Chequeo de casillas  
	AFIRMAR(juego.Disputada(0));   //Casilla1 disputada por jugador0 y 2		
	AFIRMAR(juego.Dominada(1));
	ASEGURAR(juego.Dominador(1), 1);
	AFIRMAR(juego.Dominada(2));
	ASEGURAR(juego.Dominador(2), 0);
	AFIRMAR(juego.Dominada(3));
	ASEGURAR(juego.Dominador(3), 2);
	AFIRMAR(juego.Vacia(4));
	AFIRMAR(juego.Dominada(5));
	ASEGURAR(juego.Dominador(5), 2);
	
	itMult = juego.Fichas(0);		//1 ficha del jugador 0 y otra del 2 en casilla 0
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	AFIRMAR(itMult.Siguiente() == 0 || itMult.Siguiente() == 2 );
	ASEGURAR(itMult.CardinalSiguiente() ,  1);
	itMult.Avanzar();
	AFIRMAR(itMult.HaySiguiente());
	AFIRMAR((itMult.Siguiente() == 2 && itMult.Anterior() == 0) || (itMult.Siguiente() == 0 && itMult.Anterior() == 2));
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
		
	itMult = juego.Fichas(1);   //Se mantienen las 2 fichas del jugador 1 en casilla 1      
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente() ,  1);
	ASEGURAR(itMult.CardinalSiguiente(), 2);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
		
	itMult = juego.Fichas(2);   //Se mantienen las 2 fichas del jugador 0 en casilla 2      
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 0);
	ASEGURAR(itMult.CardinalSiguiente(), 2);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
		
	itMult = juego.Fichas(3);   //Queda 1 ficha del jugador 2 en casilla 3       
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 2);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
		
	itMult = juego.Fichas(4);   //Continúa vacía la casilla 4      
	NEGAR(itMult.HayAnterior());
	NEGAR(itMult.HaySiguiente());
		
	itMult = juego.Fichas(5);   //Se mantiene 1 ficha del jugador 2 en casilla 5      
	NEGAR(itMult.HayAnterior());
	AFIRMAR(itMult.HaySiguiente());
	ASEGURAR(itMult.Siguiente(), 2);
	ASEGURAR(itMult.CardinalSiguiente(), 1);
	itMult.Avanzar();
	NEGAR(itMult.HaySiguiente());
}


void test_finalizacion(ostream&){

	// ++ Se crear el Tablero a utilizar en el Juego (6 casillas en total)
	Tablero<String> t;

	String m0("mcero"), m1("muno"), m2("mdos"), m2_2("mdosbis"), m3("mtres"),
			m4("mcuatro"), m5("mcinco"), m_sarasa("sarasa");

	//Se agrega una nueva casilla en un el mismo continente que 0, conectada de ida y vuelta con la casilla
	t.Contener(0, m0, m1);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(1, m1, m2);
	//Se agrega una nueva conexión de 1 a 2
	t.Movilizar(1, 2, m2_2);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m3);
	//Se agrega una conexión de ida y vuelta entre 0 y 3
	t.Conectar(0, 3, m3, m0);
	//Se agrega una nueva casilla en el mismo continente que 2, conectada de ida y vuelta con la casilla
	t.Contener(2, m2, m4);
	//Se agrega una nueva casilla en el nuevo continente, conectada de ida y vuelta con la casilla 1
	t.Agregar(4, m4, m5);

	// ++ Se crean los vectores de casillas iniciales y misiones para 3 jugadores
	Vector<Casilla> cs;
	Vector<Mision> ms;
	//Jugador 0
	cs.AgregarAtras(2);
	ms.AgregarAtras(1);
	//Jugador 1
	cs.AgregarAtras(1);
	ms.AgregarAtras(2);
	//Jugador 2
	cs.AgregarAtras(5);
	ms.AgregarAtras(0);

	// ## CASO 1: Gana el jugador 0 con un Agregar Ficha

	Juego juego(t, cs, ms);// Se crea la instancia de Juego

	juego.AgregarFicha(0, 3); //El jugador 0 pone una ficha en la casilla 3
	juego.AgregarFicha(1, 4); //El jugador 1 pone una ficha en la casilla 4
	juego.AgregarFicha(2, 5); //El jugador 2 pone una ficha en la casilla 5

	juego.AgregarFicha(0, 2); //El jugador 0 pone una ficha en la casilla 2
	juego.AgregarFicha(1, 4); //El jugador 1 pone una ficha en la casilla 4
	juego.AgregarFicha(2, 5); //El jugador 2 pone una ficha en la casilla 5

	juego.AgregarFicha(0, 3); //El jugador 0 pone una ficha en la casilla 3
	juego.Mover(1, m5, 2); //El jug 1 mueve 2 fichas a la casilla 5 (no hay batallas al momento)
	juego.AgregarFicha(2, 0); //El jugador 2 pone una ficha en la casilla 0

	juego.AgregarFicha(0, 4); //El jugador 0 pone una ficha en la casilla 3


	AFIRMAR(juego.Finalizado()); // -- El juego tiene que haber finalizado
	ASEGURAR(juego.CumplieronMision().Cardinal() ,  1); // Un solo jugador cumplió la misión
	AFIRMAR(juego.MisionCumplida(0)); // El jugador 0 cumplió la misión
	NEGAR(juego.MisionCumplida(1)); //El jugador 1 no cumplió la misión
	NEGAR(juego.MisionCumplida(2)); //El jugador 2 no cumplió la misión

	ConjAcotado ganadores = juego.Ganadores();
	ConjAcotado::const_Iterador itGan = ganadores.CrearIt();
	NEGAR(itGan.HayAnterior()); //Hay un solo ganador y es el jugador 0
	AFIRMAR(itGan.HaySiguiente());
	ASEGURAR(itGan.Siguiente() ,  0);
	itGan.Avanzar();
	NEGAR(itGan.HaySiguiente());


	// ## CASO 2: Ganan los jugadores 0 y 1 luego de un movimiento

	Juego juego2(t, cs, ms);// Se crea la instancia de Juego
	juego2.AgregarFicha(0, 3); //El jugador 0 pone una ficha en la casilla 3
	juego2.AgregarFicha(1, 4); //El jugador 1 pone una ficha en la casilla 4
	juego2.AgregarFicha(2, 0); //El jugador 2 pone una ficha en la casilla 0

	juego2.AgregarFicha(0, 2); //El jugador 0 pone una segunda ficha en la casilla 2
	juego2.AgregarFicha(1, 4); //El jugador 1 pone una segunda ficha en la casilla 4
	juego2.AgregarFicha(2, 5); //El jugador 2 pone una ficha en la casilla 5

	juego2.AgregarFicha(0, 3); //El jugador 0 pone una ficha en la casilla 3
	juego2.Mover(1, m5, 2); //El jug 1 mueve 2 fichas a la casilla 5 (no hay batallas al momento)
	juego2.AgregarFicha(2, 0); //El jugador 2 pone una segunda ficha en la casilla 0

	juego2.Mover(0, m4, 1); //El jugador 0 mueve 1 ficha a la casilla 4
	juego2.Mover(1, m_sarasa, 1); //El jugador 1 hace un movimiento para generar una batalla
	
	//Gana el jugador 0 porque domina todas las casillas del continente 1,
	// y el jugador 1 gana porque el jugador 2 perdió sus dos fichas en dos batallas sucesivas


	//Se chequean las casillas
	AFIRMAR(juego2.Dominada(0));
	ASEGURAR(juego2.Dominador(0), 2);
	AFIRMAR(juego2.Dominada(1));
	ASEGURAR(juego2.Dominador(1), 1);
	AFIRMAR(juego2.Dominada(2));
	ASEGURAR(juego2.Dominador(2), 0);
	AFIRMAR(juego2.Dominada(3));
	ASEGURAR(juego2.Dominador(3), 0);
	AFIRMAR(juego2.Dominada(4));
	ASEGURAR(juego2.Dominador(4), 0);
	AFIRMAR(juego2.Dominada(5));
	ASEGURAR(juego2.Dominador(5) ,  1);

	AFIRMAR(juego2.Finalizado()); // -- El juego tiene que haber finalizado
	ASEGURAR(juego2.CumplieronMision().Cardinal() ,  2); // Dos jugadores cumplieron la misión
	AFIRMAR(juego2.MisionCumplida(0)); // El jugador 0 cumplió la misión
	AFIRMAR(juego2.MisionCumplida(1)); // El jugador 1 cumplió la misión
	NEGAR(juego2.MisionCumplida(2)); // El jugador 2 no cumplió la misión

	ASEGURAR(juego2.CantidadConFichas(), 3); //Ningún jugador se quedó sin fichas
	
	ganadores = juego2.Ganadores();
	itGan = ganadores.CrearIt();
	NEGAR(itGan.HayAnterior()); //Hay un solo ganador y es el jugador 0
	AFIRMAR(itGan.HaySiguiente());
	AFIRMAR(itGan.Siguiente() == 0 || itGan.Siguiente() == 1);
	itGan.Avanzar();
	AFIRMAR(itGan.HaySiguiente());
	AFIRMAR((itGan.Siguiente() == 0 && itGan.Anterior() == 1) || (itGan.Siguiente() == 1 && itGan.Anterior() == 0));
	itGan.Avanzar();
	NEGAR(itGan.HaySiguiente());

	// ## CASO 3: Ganan el jugador 0 porque es el único que se quedó con fichas

	Juego juego3(t, cs, ms);// Se crea la instancia de Juego
	juego3.AgregarFicha(0, 0); //El jugador 0 pone una ficha en la casilla 0
	juego3.AgregarFicha(1, 3); //El jugador 1 pone una ficha en la casilla 3
	juego3.AgregarFicha(2, 4); //El jugador 2 pone una ficha en la casilla 4

	juego3.AgregarFicha(0, 2); //El jugador 0 pone una ficha en la casilla 2
	juego3.Mover(1, m2, 1); //El jugador 1 mueve 1 ficha a través del mov mdos (2 fichas en total)
	juego3.AgregarFicha(2, 1); //El jugador 2 pone una ficha en la casilla 1

	juego3.AgregarFicha(0, 3); //El jugador 0 pone una ficha en la casilla 3
	juego3.Mover(1, m_sarasa, 1); //El jug 1 posibilita una batalla (pierde 1 ficha por la batalla en casilla 2)
	juego3.AgregarFicha(2, 4); //El jugador 2 pone una ficha en la casilla 4

	juego3.Mover(0, m3, 1); //El jugador 0 mueve 1 ficha a la casilla 3 (el jug 1 pierde una ficha y queda fuera del juego)

	//Se chequean las casillas
	AFIRMAR(juego3.Vacia(0));
	AFIRMAR(juego3.Dominada(1));
	ASEGURAR(juego3.Dominador(1), 2);
	AFIRMAR(juego3.Dominada(2));
	ASEGURAR(juego3.Dominador(2), 0);
	AFIRMAR(juego3.Dominada(3));
	ASEGURAR(juego3.Dominador(3), 0);
	AFIRMAR(juego3.Dominada(4));
	ASEGURAR(juego3.Dominador(4), 2);
	AFIRMAR(juego3.Dominada(5));
	ASEGURAR(juego3.Dominador(5) ,  2);
	
	//std::cout << "Eliminados: " << juego3.Eliminados() << std::endl;
	ASEGURAR(juego3.Eliminados().Cardinal(), 1); 		// Hay un solo eliminado
	ASEGURAR(juego3.Eliminados().CrearIt().Siguiente(), 1);	// y es el Jugador 1

	juego3.AgregarFicha(2, 0); //El jugador 2 pone una ficha en la casilla 0

	juego3.Mover(0, m0, 1); //El jugador 0 mueve 1 ficha a la casilla 0
	juego3.Mover(2, m0, 1); //El jugador 2 mueve 1 ficha a la casilla 0 (el jug 2 pierde 1 ficha por batalla en casilla 0)

	juego3.AgregarFicha(0, 3); //El jugador 0 pone 1 ficha en la casilla 3
	juego3.Mover(2, m2, 2); //El jugador 2 mueve 2 fichas a la casilla 2 (el jug 2 pierde 1 ficha por batalla en casilla 0)

	juego3.Mover(0, m2, 1); //El jugador 0 mueve 1 ficha a la casilla 2 (el jug 2 pierde 1 ficha por batalla en casilla 2)
	juego3.AgregarFicha(2, 1); //El jugador 2 pone una ficha en la casilla 1
	
	juego3.Mover(0, m1, 1); //El jugador 0 mueve 1 ficha a la casilla 1 (el jug 2 pierde 1 ficha por batalla en casilla 2)
	juego3.AgregarFicha(2, 5); //El jugador 2 pone una ficha en la casilla 5

	juego3.Mover(0, m4, 2); //El jugador 0 mueve 2 fichas a la casilla 4 (el jug 2 pierde 1 ficha por batalla en casilla 1)
	juego3.Mover(2, m4, 2); //El jugador 2 mueve 2 fichas a la casilla 4
	
	juego3.AgregarFicha(0, 5); //El jugador 0 pone una ficha en la casilla 5
	juego3.AgregarFicha(2, 0); //El jugador 0 pone una ficha en la casilla 0

	juego3.AgregarFicha(0, 1); //El jugador 0 pone una ficha en la casilla 1
	juego3.AgregarFicha(2, 0); //El jugador 0 pone otra ficha en la casilla 0
	
	juego3.Mover(0, m0, 1); //El jugador 0 mueve 1 ficha desde la casilla 3 y otra desde la casilla 1 hacia la casilla 0 (el jug 2 pierde 1 ficha por batalla en casilla 4)
	juego3.Mover(2, m_sarasa, 1); //El jugador 2 permite una batalla (el jug pierde 1 ficha por batalla en la casilla 0)

	juego3.Mover(0, m_sarasa, 1);  //El jugador 0 permite una batalla  (el jug pierde 1 ficha por batalla en la casilla 0)
	
	//Se chequean las casillas
	AFIRMAR(juego3.Dominada(0));
	ASEGURAR(juego3.Dominador(0), 0);
	AFIRMAR(juego3.Dominada(1));
	ASEGURAR(juego3.Dominador(1), 0);
	AFIRMAR(juego3.Vacia(2));
	AFIRMAR(juego3.Vacia(3));
	AFIRMAR(juego3.Dominada(4));
	ASEGURAR(juego3.Dominador(4), 0);
	AFIRMAR(juego3.Dominada(5));
	ASEGURAR(juego3.Dominador(5), 0);
	
	AFIRMAR(juego3.Finalizado()); // -- El juego tiene que haber finalizado
	ASEGURAR(juego3.CumplieronMision().Cardinal(), 0); // Ningún jugador cumplió la misión

// 	ASEGURAR(juego3.Eliminados().Cardinal(), 2); // Quedaron eliminados dos jugadores
// 	ConjAcotado eliminados = juego3.Eliminados();
// 	ConjAcotado::const_Iterador itPerd = eliminados.CrearIt();
// 	NEGAR(itPerd.HayAnterior()); //Hay dos eliminados
// 	AFIRMAR(itPerd.HaySiguiente());
// 	AFIRMAR(itPerd.Siguiente() == 1 || itPerd.Siguiente() == 2);
// 	itPerd.Avanzar();
// 	AFIRMAR(itPerd.HaySiguiente());
// 	AFIRMAR((itPerd.Siguiente() == 1 && itPerd.Anterior() == 2) || (itPerd.Siguiente() == 2 && itPerd.Anterior() == 1));
// 	itPerd.Avanzar();
// 	NEGAR(itPerd.HaySiguiente());

	ganadores = juego3.Ganadores();
	ASEGURAR(ganadores.Cardinal(), 1); //Ganó un solo jugador
	itGan = ganadores.CrearIt();
	NEGAR(itGan.HayAnterior()); //Hay un solo ganador y es el jugador 0
	AFIRMAR(itGan.HaySiguiente());
	ASEGURAR(itGan.Siguiente(), 0);
	itGan.Avanzar();
	NEGAR(itGan.HaySiguiente());
}

int main(void) {
	Tester& tester = *Tester::Instance();
	
	tester.NuevoSet("Juego");
	tester.UsarSet("Juego");
	tester.Declarar("Creacion", &test_crear);
	tester.Declarar("AgregarFicha", &test_agregarFicha);
	tester.Declarar("Mover", &test_mover);
	tester.Declarar("Finalización del Juego", &test_finalizacion);
	tester.setVerborragia(3);

	tester.Ejecutar("Juego");

	return 0;
}
